/**
 * 缓存管理路由
 * 处理模型上传缓存相关的操作
 */
const express = require('express');
const router = express.Router();
const fs = require('fs').promises;
const path = require('path');
const multer = require('multer');
const { PROJECTS_DIR } = require('../utils/constants');
const { generateId } = require('../utils/helpers');
const { readProjectsIndex } = require('../services/projectService');

// 配置缓存上传的 multer
const cacheStorage = multer.diskStorage({
    destination: async (req, file, cb) => {
        // 从查询参数中获取项目ID
        const projectId = req.query.projectId;
        if (!projectId) {
            return cb(new Error('缺少项目ID参数'));
        }
        
        try {
            // 查找项目信息
            const index = await readProjectsIndex();
            const projectMeta = index.projects.find(p => p.id === projectId);
            
            if (!projectMeta) {
                return cb(new Error('项目不存在'));
            }
            
            const cacheDir = path.join(PROJECTS_DIR, 'cache', 'uploadmodel', projectMeta.path);
            await fs.mkdir(cacheDir, { recursive: true });
            cb(null, cacheDir);
        } catch (error) {
            cb(error);
        }
    },
    filename: (req, file, cb) => {
        // 临时文件名，添加随机字符串避免并发冲突
        const randomStr = Math.random().toString(36).substring(2, 15);
        const tempName = `temp-${Date.now()}-${randomStr}${path.extname(file.originalname)}`;
        cb(null, tempName);
    }
});

const cacheUpload = multer({
    storage: cacheStorage,
    limits: {
        fileSize: 50 * 1024 * 1024 // 限制50MB
    },
    fileFilter: (req, file, cb) => {
        const allowedExts = ['.glb', '.gltf', '.fbx'];
        const ext = path.extname(file.originalname).toLowerCase();
        
        if (allowedExts.includes(ext)) {
            console.log(`✅ [Cache Upload] 接收文件: ${file.originalname}`);
            cb(null, true);
        } else {
            cb(new Error(`不支持的文件格式: ${ext}，仅支持 ${allowedExts.join(', ')}`));
        }
    }
});

/**
 * 清空上传缓存
 * POST /api/cache/clear
 * Body: { projectId }
 */
router.post('/clear', async (req, res) => {
    try {
        const { projectId } = req.body;
        
        if (!projectId) {
            return res.status(400).json({
                success: false,
                error: '缺少项目ID参数'
            });
        }
        
        // 查找项目信息
        const index = await readProjectsIndex();
        const projectMeta = index.projects.find(p => p.id === projectId);
        
        if (!projectMeta) {
            return res.status(404).json({
                success: false,
                error: '项目不存在'
            });
        }
        
        const cacheDir = path.join(PROJECTS_DIR, 'cache', 'uploadmodel', projectMeta.path);
        
        // 检查目录是否存在
        try {
            await fs.access(cacheDir);
            // 目录存在，删除整个目录
            await fs.rm(cacheDir, { recursive: true, force: true });
            console.log(`🗑️ [Cache Clear] 缓存目录已删除: ${projectMeta.path}`);
        } catch (err) {
            // 目录不存在，忽略
            console.log(`ℹ️ [Cache Clear] 缓存目录不存在，跳过删除: ${projectMeta.path}`);
        }
        
        // 重新创建空目录
        await fs.mkdir(cacheDir, { recursive: true });
        console.log(`✅ [Cache Clear] 缓存目录已重建: ${projectMeta.path}`);
        
        res.json({
            success: true,
            message: '缓存已清空'
        });
        
    } catch (error) {
        console.error('❌ [Cache Clear] 清空缓存失败:', error);
        res.status(500).json({
            success: false,
            error: error.message
        });
    }
});

/**
 * 上传模型到缓存目录（第一阶段）
 * POST /api/cache/upload
 * Body: { projectId, originalFileName }
 */
router.post('/upload', cacheUpload.single('model'), async (req, res) => {
    try {
        const { originalFileName, projectId } = req.body;
        
        if (!req.file) {
            return res.status(400).json({
                success: false,
                error: '请选择要上传的模型文件'
            });
        }
        
        if (!projectId) {
            return res.status(400).json({
                success: false,
                error: '缺少项目ID参数'
            });
        }
        
        // 使用 multer 已经保存文件的目录（req.file.destination）
        const cacheDir = req.file.destination;
        
        // 生成模型ID
        const modelId = generateId('model');
        
        // 优先使用前端传来的正确文件名
        const correctFileName = originalFileName || req.file.originalname;
        const ext = path.extname(correctFileName);
        const displayName = correctFileName.replace(ext, '');
        
        // 将临时文件重命名为正式文件名
        const tempPath = req.file.path;
        const targetPath = path.join(cacheDir, `${modelId}${ext}`);
        
        console.log(`📂 [Cache Upload] 临时文件: ${tempPath}`);
        console.log(`📂 [Cache Upload] 目标路径: ${targetPath}`);
        
        await fs.rename(tempPath, targetPath);
        
        console.log(`✅ [Cache Upload] 文件已保存: ${correctFileName} -> ${modelId}${ext}`);
        
        // 创建模型元数据（暂时不包含meshMaterials，这个将在前端解析后添加）
        const modelMetadata = {
            id: modelId,
            displayName: displayName,
            filename: correctFileName,
            size: req.file.size,
            tags: [],
            path: `models/${modelId}${ext}`,
            updatedAt: new Date().toISOString(),
            meshMaterials: {} // 将在前端解析后填充
        };
        
        // 🎯 为每个模型创建独立的 JSON 配置文件
        const modelJsonPath = path.join(cacheDir, `${modelId}.json`);
        await fs.writeFile(modelJsonPath, JSON.stringify(modelMetadata, null, 2), 'utf-8');
        
        console.log(`✅ [Cache Upload] 模型已上传到缓存:`, displayName);
        res.json({
            success: true,
            data: modelMetadata
        });
        
    } catch (error) {
        console.error('❌ [Cache Upload] 上传到缓存失败:', error);
        res.status(500).json({
            success: false,
            error: error.message
        });
    }
});

/**
 * 更新缓存中的模型mesh材质信息
 * PUT /api/cache/:modelId/meshMaterials
 * Body: { projectId, meshMaterials }
 */
router.put('/:modelId/meshMaterials', async (req, res) => {
    try {
        const { modelId } = req.params;
        const { meshMaterials, projectId } = req.body;
        
        if (!projectId) {
            return res.status(400).json({
                success: false,
                error: '缺少项目ID参数'
            });
        }
        
        // 查找项目信息
        const index = await readProjectsIndex();
        const projectMeta = index.projects.find(p => p.id === projectId);
        
        if (!projectMeta) {
            return res.status(404).json({
                success: false,
                error: '项目不存在'
            });
        }
        
        const cacheDir = path.join(PROJECTS_DIR, 'cache', 'uploadmodel', projectMeta.path);
        const modelJsonPath = path.join(cacheDir, `${modelId}.json`);
        
        // 读取模型配置文件
        let modelData;
        try {
            const jsonData = await fs.readFile(modelJsonPath, 'utf-8');
            modelData = JSON.parse(jsonData);
        } catch (err) {
            return res.status(404).json({
                success: false,
                error: '模型不存在'
            });
        }
        
        // 更新 meshMaterials
        modelData.meshMaterials = meshMaterials;
        modelData.updatedAt = new Date().toISOString();
        
        // 写回文件
        await fs.writeFile(modelJsonPath, JSON.stringify(modelData, null, 2), 'utf-8');
        
        console.log(`✅ [Cache Update] 模型mesh材质信息已更新 [${projectMeta.path}]:`, modelId);
        res.json({
            success: true,
            data: modelData
        });
        
    } catch (error) {
        console.error('❌ [Cache Update] 更新mesh材质信息失败:', error);
        res.status(500).json({
            success: false,
            error: error.message
        });
    }
});

/**
 * 获取缓存中的模型列表
 * GET /api/cache?projectId=xxx
 */
router.get('/', async (req, res) => {
    try {
        const { projectId } = req.query;
        
        if (!projectId) {
            return res.status(400).json({
                success: false,
                error: '缺少项目ID参数'
            });
        }
        
        // 查找项目信息
        const index = await readProjectsIndex();
        const projectMeta = index.projects.find(p => p.id === projectId);
        
        if (!projectMeta) {
            return res.status(404).json({
                success: false,
                error: '项目不存在'
            });
        }
        
        const cacheDir = path.join(PROJECTS_DIR, 'cache', 'uploadmodel', projectMeta.path);
        
        // 确保目录存在
        try {
            await fs.access(cacheDir);
        } catch (err) {
            // 目录不存在，返回空列表
            return res.json({
                success: true,
                data: []
            });
        }
        
        // 读取目录中的所有文件
        const files = await fs.readdir(cacheDir);
        
        // 找出所有 .json 文件
        const jsonFiles = files.filter(file => file.endsWith('.json'));
        
        // 读取所有模型配置
        const models = [];
        for (const jsonFile of jsonFiles) {
            try {
                const jsonPath = path.join(cacheDir, jsonFile);
                const jsonData = await fs.readFile(jsonPath, 'utf-8');
                const modelData = JSON.parse(jsonData);
                models.push(modelData);
            } catch (err) {
                console.warn(`⚠️ [Cache Get] 读取配置文件失败: ${jsonFile}`, err.message);
            }
        }
        
        console.log(`✅ [Cache Get] 获取缓存模型列表 [${projectMeta.path}]: ${models.length} 个模型`);
        res.json({
            success: true,
            data: models
        });
        
    } catch (error) {
        console.error('❌ [Cache Get] 获取缓存模型列表失败:', error);
        res.status(500).json({
            success: false,
            error: error.message
        });
    }
});

module.exports = router;

